package com.delio.client.series;


import com.delio.client.produccion.pedidos.PedidoForm;
import com.extjs.gxt.ui.client.data.BaseFilterPagingLoadConfig;
import com.extjs.gxt.ui.client.data.BasePagingLoadConfig;
import com.extjs.gxt.ui.client.data.BasePagingLoader;
import com.extjs.gxt.ui.client.data.BeanModel;
import com.extjs.gxt.ui.client.data.BeanModelReader;
import com.extjs.gxt.ui.client.data.FilterPagingLoadConfig;
import com.extjs.gxt.ui.client.data.ListLoadResult;
import com.extjs.gxt.ui.client.data.ListLoader;
import com.extjs.gxt.ui.client.data.ModelData;
import com.extjs.gxt.ui.client.data.PagingLoadResult;
import com.extjs.gxt.ui.client.data.PagingLoader;
import com.extjs.gxt.ui.client.data.RpcProxy;
import com.extjs.gxt.ui.client.store.ListStore;
import com.extjs.gxt.ui.client.widget.MessageBox;
import com.google.gwt.core.client.GWT;
import com.google.gwt.user.client.rpc.AsyncCallback;


public class Series {
	private static SerieServiceAsync ss = GWT.create(SerieService.class);
	public static PagingLoader<PagingLoadResult<ModelData>> loader;
	public static ListStore<BeanModel> store;
	public static ListStore<BeanModel> storeCombo;
	public static ListLoader<ListLoadResult<ModelData>> loaderCombo;
    public static SerieForm sf;
/*	
	public static void getPaginate() {
		RpcProxy<PagingLoadResult<Serie>> proxy = new RpcProxy<PagingLoadResult<Serie>>() {

			@Override
			protected void load(Object loadConfig,
			      AsyncCallback<PagingLoadResult<Serie>> callback) {
				ss.paginateSerie((FilterPagingLoadConfig) loadConfig, callback);  
			}  
	    };
	    loader = new BasePagingLoader<PagingLoadResult<ModelData>>(proxy, new BeanModelReader()){  
	        @Override  
	        protected Object newLoadConfig() {  
	          BasePagingLoadConfig config = new BaseFilterPagingLoadConfig();  
	          return config;  
	        }  
	      };  
        loader.setRemoteSort(true);  
        store = new ListStore<BeanModel>(loader);
 }
	
	 public static void guardar(final Serie s){
		 
		 ss.guardar(s, new AsyncCallback<Boolean>(){

			@Override
			public void onFailure(Throwable caught) {
				MessageBox.alert("Error", "No pudo guardar", null);			
			}

			@Override
			public void onSuccess(Boolean result) {
				
				System.out.println("todo salio bien codigo tipodocumentos"+s.getTipodocumento_id());
		       if(result){
	            MessageBox.alert("Guardado", "Se guardo Correctament", null);
	            sf.clearForm();
	            sf.dl.hide();
	           }else{
	        	MessageBox.alert("Error", "No se guardo correctamente", null);
	           }
				
			}
		 
		 });
	 }	 
	 
	 public static void actualizar(Serie s){
		 
		 ss.actualizar(s, new AsyncCallback<Boolean>(){

			@Override
			public void onFailure(Throwable caught) {
				MessageBox.alert("Error", "No pudo actualizar", null);			
			}

			@Override
			public void onSuccess(Boolean result) {
	           if(result){
	            MessageBox.alert("Actualizado", "Se actualizo Correctament", null);     	   
	           }else{
	        	MessageBox.alert("Error", "No se actualizo correctamente", null);
	           }
			}
	    });
	 }
	 
	 public static void actualizarOp(int id){
		
	 }
	 
	 public static void getSerie(final int tdid){
		 ss.getSerie(tdid, new AsyncCallback<Integer>(){

			@Override
			public void onFailure(Throwable caught) {
				MessageBox.alert("Error", "No se pudo recuperar el idserie", null);			
		    }

			@Override
			public void onSuccess(Integer result) {
			    int re = result+1;
				Serie se = new Serie();
				se.setUltimonumero(""+re);
				se.setTipodocumento_id(tdid);
			    if(tdid==1){
				  System.out.println("id aumentado"+re);
				  PedidoForm.getSerie(re);
				  
				  Series.actualizarNOP(se);
			  }else
				MessageBox.alert("Error", "orden de pedido deberia ser 1", null);
		    }
        });
	 }

	protected static void actualizarNOP(final Serie se) {
	    ss.actualizarNOP(se, new AsyncCallback<Boolean>(){
      
		@Override
		public void onFailure(Throwable caught) {
			MessageBox.alert("Error", "No pudo actualizar", null);			
		}
		@Override
		public void onSuccess(Boolean result) {
		    System.out.println("el ultimo numero es**********"+se.getUltimonumero());		
		    System.out.println("el codigo es**********"+se.getTipodocumento_id());		
			}
    	
	    });
	}
	
	 public static void eliminar(int id){
		 ss.eliminar(id, new AsyncCallback<Boolean>(){
			
			 @Override
			 public void onFailure(Throwable caught){
				 MessageBox.alert("Error", "Error en la Eliminacion", null);
			 }
			 
			 public void onSuccess(Boolean result){
				 if(result){
				   MessageBox.alert("Eliminado","Se elimino Correctamente", null); 
				 }else{
				   MessageBox.alert("Error", "No se elimino Correctamente", null);	 
				 } 
			 }

		 });
	 }
	*/
}